gtktexttypes.h \
gtktextutil.h \
gtktypebuiltins.h \
+ gtkxembed.h \
xembed.h
# CFLAGS and LDFLAGS for compiling scan program. Only needed
gtk_plug_c_sources = \
gtkplug.c \
- gtksocket.c
+ gtksocket.c \
+ gtkxembed.c \
+ gtkxembed.h
# we use our own built_sources variable rules to avoid automake's
# BUILT_SOURCES oddities
#include "gdk/gdkkeysyms.h"
#include "x11/gdkx.h"
-#include "xembed.h"
+#include "gtkxembed.h"
static void gtk_plug_class_init (GtkPlugClass *klass);
static void gtk_plug_init (GtkPlug *plug);
gpointer data);
static void handle_modality_off (GtkPlug *plug);
-static void send_xembed_message (GtkPlug *plug,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time);
static void xembed_set_info (GdkWindow *window,
unsigned long flags);
if (focus && !window->has_toplevel_focus)
{
- send_xembed_message (plug, XEMBED_REQUEST_FOCUS, 0, 0, 0,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (plug->socket_window,
+ XEMBED_REQUEST_FOCUS, 0, 0, 0);
}
}
if (!plug->grabbed_keys ||
!g_hash_table_lookup (plug->grabbed_keys, grabbed_key))
{
- send_xembed_message (plug, XEMBED_GTK_GRAB_KEY, 0,
- grabbed_key->accelerator_key, grabbed_key->accelerator_mods,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (plug->socket_window, XEMBED_GTK_GRAB_KEY, 0,
+ grabbed_key->accelerator_key, grabbed_key->accelerator_mods);
}
}
GrabbedKey *grabbed_key = key;
GtkPlug *plug = data;
- send_xembed_message (plug, XEMBED_GTK_GRAB_KEY, 0,
- grabbed_key->accelerator_key, grabbed_key->accelerator_mods,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (plug->socket_window, XEMBED_GTK_GRAB_KEY, 0,
+ grabbed_key->accelerator_key, grabbed_key->accelerator_mods);
}
static void
if (!plug->grabbed_keys ||
!g_hash_table_lookup (plug->grabbed_keys, grabbed_key))
{
- send_xembed_message (plug, XEMBED_GTK_UNGRAB_KEY, 0,
- grabbed_key->accelerator_key, grabbed_key->accelerator_mods,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (plug->socket_window, XEMBED_GTK_UNGRAB_KEY, 0,
+ grabbed_key->accelerator_key, grabbed_key->accelerator_mods);
}
}
}
}
+static void
+focus_to_parent (GtkPlug *plug,
+ GtkDirectionType direction)
+{
+ XEmbedMessageType message = XEMBED_FOCUS_PREV; /* Quiet GCC */
+
+ switch (direction)
+ {
+ case GTK_DIR_UP:
+ case GTK_DIR_LEFT:
+ case GTK_DIR_TAB_BACKWARD:
+ message = XEMBED_FOCUS_PREV;
+ break;
+ case GTK_DIR_DOWN:
+ case GTK_DIR_RIGHT:
+ case GTK_DIR_TAB_FORWARD:
+ message = XEMBED_FOCUS_NEXT;
+ break;
+ }
+
+ _gtk_xembed_send_focus_message (plug->socket_window, message, 0);
+}
+
static gboolean
gtk_plug_focus (GtkWidget *widget,
GtkDirectionType direction)
}
gtk_window_set_focus (GTK_WINDOW (container), NULL);
-
- if (!GTK_CONTAINER (window)->focus_child)
- {
- gint message = -1;
-
- switch (direction)
- {
- case GTK_DIR_UP:
- case GTK_DIR_LEFT:
- case GTK_DIR_TAB_BACKWARD:
- message = XEMBED_FOCUS_PREV;
- break;
- case GTK_DIR_DOWN:
- case GTK_DIR_RIGHT:
- case GTK_DIR_TAB_FORWARD:
- message = XEMBED_FOCUS_NEXT;
- break;
- }
-
- send_xembed_message (plug, message, 0, 0, 0,
- gtk_get_current_event_time ());
- }
}
-
- return FALSE;
}
else
{
/* Try to focus the first widget in the window */
-
if (bin->child && gtk_widget_child_focus (bin->child, direction))
return TRUE;
}
+ if (!GTK_CONTAINER (window)->focus_child)
+ focus_to_parent (plug, direction);
+
return FALSE;
}
GTK_CONTAINER_CLASS (bin_class)->check_resize (container);
}
-static void
-send_xembed_message (GtkPlug *plug,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time)
-{
- if (plug->socket_window)
- {
- GdkDisplay *display = gdk_drawable_get_display (plug->socket_window);
- XEvent xevent;
-
- GTK_NOTE(PLUGSOCKET,
- g_message ("GtkPlug: Sending XEMBED message of type %ld", message));
-
- xevent.xclient.window = GDK_WINDOW_XWINDOW (plug->socket_window);
- xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");
- xevent.xclient.format = 32;
- xevent.xclient.data.l[0] = time;
- xevent.xclient.data.l[1] = message;
- xevent.xclient.data.l[2] = detail;
- xevent.xclient.data.l[3] = data1;
- xevent.xclient.data.l[4] = data2;
-
- gdk_error_trap_push ();
- XSendEvent (GDK_WINDOW_XDISPLAY(plug->socket_window),
- GDK_WINDOW_XWINDOW (plug->socket_window),
- False, NoEventMask, &xevent);
- gdk_display_sync (display);
- gdk_error_trap_pop ();
- }
-}
-
static void
focus_first_last (GtkPlug *plug,
GtkDirectionType direction)
{
GtkWindow *window = GTK_WINDOW (plug);
GtkWidget *parent;
-
+
if (window->focus_widget)
{
parent = window->focus_widget->parent;
Atom xembed_info_atom = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED_INFO");
- buffer[1] = 0; /* Protocol version */
+ buffer[1] = GTK_XEMBED_PROTOCOL_VERSION;
buffer[1] = flags;
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
}
static void
-handle_xembed_message (GtkPlug *plug,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time)
+handle_xembed_message (GtkPlug *plug,
+ XEmbedMessageType message,
+ glong detail,
+ glong data1,
+ glong data2,
+ guint32 time)
{
GtkWindow *window = GTK_WINDOW (plug);
-
+
GTK_NOTE (PLUGSOCKET,
- g_message ("GtkPlug: Message of type %ld received", message));
+ g_message ("GtkPlug: Message of type %d received", message));
switch (message)
{
case XEMBED_REQUEST_FOCUS:
case XEMBED_FOCUS_NEXT:
case XEMBED_FOCUS_PREV:
- g_warning ("GtkPlug: Invalid _XEMBED message of type %ld received", message);
+ g_warning ("GtkPlug: Invalid _XEMBED message of type %d received", message);
break;
default:
GTK_NOTE(PLUGSOCKET,
- g_message ("GtkPlug: Ignoring unknown _XEMBED message of type %ld", message));
+ g_message ("GtkPlug: Ignoring unknown _XEMBED message of type %d", message));
break;
}
}
case ClientMessage:
if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
+ _gtk_xembed_push_message (xevent);
handle_xembed_message (plug,
xevent->xclient.data.l[1],
xevent->xclient.data.l[2],
xevent->xclient.data.l[3],
xevent->xclient.data.l[4],
xevent->xclient.data.l[0]);
+ _gtk_xembed_pop_message ();
-
return GDK_FILTER_REMOVE;
}
else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "WM_DELETE_WINDOW"))
#include "x11/gdkx.h"
-#include "xembed.h"
+#include "gtkxembed.h"
typedef struct _GtkSocketPrivate GtkSocketPrivate;
GdkEvent *event,
gpointer data);
-static void send_xembed_message (GtkSocket *socket,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time);
static gboolean xembed_get_info (GdkWindow *gdk_window,
unsigned long *version,
unsigned long *flags);
socket->focus_in = focus_in;
if (focus_in)
- {
- send_xembed_message (socket, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT, 0, 0,
- gtk_get_current_event_time ());
- }
+ _gtk_xembed_send_focus_message (socket->plug_window,
+ XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT);
else
- {
- send_xembed_message (socket, XEMBED_FOCUS_OUT, 0, 0, 0,
- gtk_get_current_event_time ());
-
- }
+ _gtk_xembed_send_message (socket->plug_window,
+ XEMBED_FOCUS_OUT, 0, 0, 0);
}
}
{
socket->active = active;
- send_xembed_message (socket,
- active ? XEMBED_WINDOW_ACTIVATE : XEMBED_WINDOW_DEACTIVATE,
- 0, 0, 0,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (socket->plug_window,
+ active ? XEMBED_WINDOW_ACTIVATE : XEMBED_WINDOW_DEACTIVATE,
+ 0, 0, 0);
}
}
GtkSocket *socket = GTK_SOCKET (widget);
if (!socket->same_app)
- send_xembed_message (GTK_SOCKET (widget),
- was_grabbed ? XEMBED_MODALITY_OFF : XEMBED_MODALITY_ON,
- 0, 0, 0, gtk_get_current_event_time ());
+ _gtk_xembed_send_message (GTK_SOCKET (widget)->plug_window,
+ was_grabbed ? XEMBED_MODALITY_OFF : XEMBED_MODALITY_ON,
+ 0, 0, 0);
}
static gboolean
break;
}
- send_xembed_message (socket, XEMBED_FOCUS_IN, detail, 0, 0,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_focus_message (socket->plug_window,
+ XEMBED_FOCUS_IN, detail);
gtk_socket_claim_focus (socket, FALSE);
socket->xembed_version = -1;
if (xembed_get_info (socket->plug_window, &version, &flags))
{
- socket->xembed_version = version;
+ socket->xembed_version = MIN (GTK_XEMBED_PROTOCOL_VERSION, version);
socket->is_mapped = (flags & XEMBED_MAPPED) != 0;
}
else
if (toplevel && GTK_IS_WINDOW (toplevel))
gtk_window_add_embedded_xid (GTK_WINDOW (toplevel), xid);
- send_xembed_message (socket, XEMBED_EMBEDDED_NOTIFY, 0, 0, 0,
- gtk_get_current_event_time ());
+ _gtk_xembed_send_message (socket->plug_window,
+ XEMBED_EMBEDDED_NOTIFY, 0,
+ GDK_WINDOW_XWINDOW (widget->window),
+ socket->xembed_version);
socket_update_active (socket);
socket_update_focus_in (socket);
g_signal_emit (socket, socket_signals[PLUG_ADDED], 0);
}
-
-static void
-send_xembed_message (GtkSocket *socket,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time)
-{
- GTK_NOTE(PLUGSOCKET,
- g_message ("GtkSocket: Sending XEMBED message of type %ld", message));
-
- if (socket->plug_window)
- {
- GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (socket));
- XEvent xevent;
-
- xevent.xclient.window = GDK_WINDOW_XWINDOW (socket->plug_window);
- xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");
- xevent.xclient.format = 32;
- xevent.xclient.data.l[0] = time;
- xevent.xclient.data.l[1] = message;
- xevent.xclient.data.l[2] = detail;
- xevent.xclient.data.l[3] = data1;
- xevent.xclient.data.l[4] = data2;
-
- gdk_error_trap_push ();
- XSendEvent (GDK_DISPLAY_XDISPLAY (display),
- GDK_WINDOW_XWINDOW (socket->plug_window),
- False, NoEventMask, &xevent);
- gdk_display_sync (display);
- gdk_error_trap_pop ();
- }
-}
-
static gboolean
xembed_get_info (GdkWindow *window,
unsigned long *version,
}
static void
-handle_xembed_message (GtkSocket *socket,
- glong message,
- glong detail,
- glong data1,
- glong data2,
- guint32 time)
+advance_toplevel_focus (GtkSocket *socket,
+ GtkDirectionType direction)
+{
+ GtkBin *bin;
+ GtkWindow *window;
+ GtkContainer *container;
+ GtkWidget *toplevel;
+ GtkWidget *old_focus_child;
+ GtkWidget *parent;
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
+ if (!toplevel)
+ return;
+
+ if (!GTK_WIDGET_TOPLEVEL (toplevel) || GTK_IS_PLUG (toplevel))
+ {
+ gtk_widget_child_focus (toplevel,direction);
+ return;
+ }
+
+ container = GTK_CONTAINER (toplevel);
+ window = GTK_WINDOW (toplevel);
+ bin = GTK_BIN (toplevel);
+
+ /* This is a copy of gtk_window_focus(), modified so that we
+ * can detect wrap-around.
+ */
+ old_focus_child = container->focus_child;
+
+ if (old_focus_child)
+ {
+ if (gtk_widget_child_focus (old_focus_child, direction))
+ return;
+
+ /* We are allowed exactly one wrap-around per sequence of focus
+ * events
+ */
+ if (_gtk_xembed_get_focus_wrapped ())
+ return;
+ else
+ _gtk_xembed_set_focus_wrapped ();
+ }
+
+ if (window->focus_widget)
+ {
+ /* Wrapped off the end, clear the focus setting for the toplevel */
+ parent = window->focus_widget->parent;
+ while (parent)
+ {
+ gtk_container_set_focus_child (GTK_CONTAINER (parent), NULL);
+ parent = GTK_WIDGET (parent)->parent;
+ }
+
+ gtk_window_set_focus (GTK_WINDOW (container), NULL);
+ }
+
+ /* Now try to focus the first widget in the window */
+ if (bin->child)
+ {
+ if (gtk_widget_child_focus (bin->child, direction))
+ return;
+ }
+}
+
+static void
+handle_xembed_message (GtkSocket *socket,
+ XEmbedMessageType message,
+ glong detail,
+ glong data1,
+ glong data2,
+ guint32 time)
{
GTK_NOTE (PLUGSOCKET,
- g_message ("GtkSocket: Message of type %ld received", message));
+ g_message ("GtkSocket: Message of type %d received", message));
switch (message)
{
case XEMBED_MODALITY_OFF:
case XEMBED_FOCUS_IN:
case XEMBED_FOCUS_OUT:
- g_warning ("GtkSocket: Invalid _XEMBED message of type %ld received", message);
+ g_warning ("GtkSocket: Invalid _XEMBED message of type %d received", message);
break;
case XEMBED_REQUEST_FOCUS:
case XEMBED_FOCUS_NEXT:
case XEMBED_FOCUS_PREV:
- {
- GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
- if (toplevel)
- {
- gtk_widget_child_focus (toplevel,
- (message == XEMBED_FOCUS_NEXT ?
- GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
- }
- break;
- }
+ advance_toplevel_focus (socket,
+ (message == XEMBED_FOCUS_NEXT ?
+ GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
+ break;
case XEMBED_GTK_GRAB_KEY:
add_grabbed_key (socket, data1, data2);
default:
GTK_NOTE (PLUGSOCKET,
- g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %ld", message));
+ g_message ("GtkSocket: Ignoring unknown _XEMBED message of type %d", message));
break;
}
}
case ClientMessage:
if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED"))
{
+ _gtk_xembed_push_message (xevent);
handle_xembed_message (socket,
xevent->xclient.data.l[1],
xevent->xclient.data.l[2],
xevent->xclient.data.l[3],
xevent->xclient.data.l[4],
xevent->xclient.data.l[0]);
-
+ _gtk_xembed_pop_message ();
return_val = GDK_FILTER_REMOVE;
}
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * gtkxembed.c: Utilities for the XEMBED protocol
+ * Copyright (C) 2001, 2003, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "gtkmain.h"
+#include "gtkprivate.h"
+#include "gtkxembed.h"
+
+typedef struct _GtkXEmbedMessage GtkXEmbedMessage;
+
+struct _GtkXEmbedMessage
+{
+ glong message;
+ glong detail;
+ glong data1;
+ glong data2;
+ guint32 time;
+};
+
+static GSList *current_messages;
+
+
+/**
+ * _gtk_xembed_push_message:
+ * @xevent: a XEvent
+ *
+ * Adds a client message to the stack of current XEMBED events.
+ **/
+void
+_gtk_xembed_push_message (XEvent *xevent)
+{
+ GtkXEmbedMessage *message = g_new (GtkXEmbedMessage, 1);
+
+ message->time = xevent->xclient.data.l[0];
+ message->message = xevent->xclient.data.l[1];
+ message->detail = xevent->xclient.data.l[2];
+ message->data1 = xevent->xclient.data.l[3];
+ message->data2 = xevent->xclient.data.l[4];
+
+ current_messages = g_slist_prepend (current_messages, message);
+}
+
+/**
+ * _gtk_xembed_pop_message:
+ *
+ * Removes an event added with _gtk_xembed_push_message()
+ **/
+void
+_gtk_xembed_pop_message (void)
+{
+ GtkXEmbedMessage *message = current_messages->data;
+ current_messages = g_slist_delete_link (current_messages, current_messages);
+
+ g_free (message);
+}
+
+/**
+ * _gtk_xembed_set_focus_wrapped:
+ *
+ * Sets a flag indicating that the current focus sequence wrapped
+ * around to the beginning of the ultimate toplevel.
+ **/
+void
+_gtk_xembed_set_focus_wrapped (void)
+{
+ GtkXEmbedMessage *message;
+
+ g_return_if_fail (current_messages != NULL);
+ message = current_messages->data;
+ g_return_if_fail (message->message == XEMBED_FOCUS_PREV || message->message == XEMBED_FOCUS_NEXT);
+
+ message->data1 |= XEMBED_FOCUS_WRAPAROUND;
+}
+
+/**
+ * _gtk_xembed_get_focus_wrapped:
+ *
+ * Gets whether the current focus sequence has wrapped around
+ * to the beginning of the ultimate toplevel.
+ *
+ * Return value: %TRUE if the focus sequence has wrapped around.
+ **/
+gboolean
+_gtk_xembed_get_focus_wrapped (void)
+{
+ GtkXEmbedMessage *message;
+
+ g_return_val_if_fail (current_messages != NULL, FALSE);
+ message = current_messages->data;
+
+ return (message->data1 & XEMBED_FOCUS_WRAPAROUND) != 0;
+}
+
+static guint32
+gtk_xembed_get_time (void)
+{
+ if (current_messages)
+ {
+ GtkXEmbedMessage *message = current_messages->data;
+ return message->time;
+ }
+ else
+ return gtk_get_current_event_time ();
+}
+
+/**
+ * _gtk_xembed_send_message:
+ * @recipient: window to which to send the window, or %NULL
+ * in which case nothing wil be sent
+ * @message: type of message
+ * @detail: detail field of message
+ * @data1: data1 field of message
+ * @data2: data2 field of message
+ *
+ * Sends a generic XEMBED message to a particular window.
+ **/
+void
+_gtk_xembed_send_message (GdkWindow *recipient,
+ XEmbedMessageType message,
+ glong detail,
+ glong data1,
+ glong data2)
+{
+ GdkDisplay *display;
+ XEvent xevent;
+
+ if (!recipient)
+ return;
+
+ g_return_if_fail (GDK_IS_WINDOW (recipient));
+
+ display = gdk_drawable_get_display (recipient);
+ GTK_NOTE (PLUGSOCKET,
+ g_message ("Sending XEMBED message of type %d", message));
+
+ xevent.xclient.window = GDK_WINDOW_XWINDOW (recipient);
+ xevent.xclient.type = ClientMessage;
+ xevent.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_XEMBED");
+ xevent.xclient.format = 32;
+ xevent.xclient.data.l[0] = gtk_xembed_get_time ();
+ xevent.xclient.data.l[1] = message;
+ xevent.xclient.data.l[2] = detail;
+ xevent.xclient.data.l[3] = data1;
+ xevent.xclient.data.l[4] = data2;
+
+ gdk_error_trap_push ();
+ XSendEvent (GDK_WINDOW_XDISPLAY(recipient),
+ GDK_WINDOW_XWINDOW (recipient),
+ False, NoEventMask, &xevent);
+ gdk_display_sync (display);
+ gdk_error_trap_pop ();
+}
+
+/**
+ * _gtk_xembed_send_focus_message:
+ * @recipient: window to which to send the window, or %NULL
+ * in which case nothing wil be sent
+ * @message: type of message
+ * @detail: detail field of message
+ *
+ * Sends a XEMBED message for moving the focus along the focus
+ * chain to a window. The flags field that these messages share
+ * will be correctly filled in.
+ **/
+void
+_gtk_xembed_send_focus_message (GdkWindow *recipient,
+ XEmbedMessageType message,
+ glong detail)
+{
+ gulong flags = 0;
+
+ g_return_if_fail (GDK_IS_WINDOW (recipient));
+ g_return_if_fail (message == XEMBED_FOCUS_IN ||
+ message == XEMBED_FOCUS_NEXT ||
+ message == XEMBED_FOCUS_PREV);
+
+ if (current_messages)
+ {
+ GtkXEmbedMessage *message = current_messages->data;
+ switch (message->message)
+ {
+ case XEMBED_FOCUS_IN:
+ case XEMBED_FOCUS_NEXT:
+ case XEMBED_FOCUS_PREV:
+ flags = message->data1 & XEMBED_FOCUS_WRAPAROUND;
+ break;
+ default:
+ break;
+ }
+ }
+
+ _gtk_xembed_send_message (recipient, message, detail, flags, 0);
+}
+
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * gtkxembed.c: Utilities for the XEMBED protocol
+ * Copyright (C) 2003, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_XEMBED_H__
+#define __GTK_XEMBED_H__
+
+#include "xembed.h"
+#include "x11/gdkx.h"
+
+G_BEGIN_DECLS
+
+/* Latest version we implement */
+#define GTK_XEMBED_PROTOCOL_VERSION 1
+
+void _gtk_xembed_send_message (GdkWindow *recipient,
+ XEmbedMessageType message,
+ glong detail,
+ glong data1,
+ glong data2);
+void _gtk_xembed_send_focus_message (GdkWindow *recipient,
+ XEmbedMessageType message,
+ glong detail);
+
+void _gtk_xembed_push_message (XEvent *xevent);
+void _gtk_xembed_pop_message (void);
+void _gtk_xembed_set_focus_wrapped (void);
+gboolean _gtk_xembed_get_focus_wrapped (void);
+
+G_END_DECLS
+
+#endif /* __GTK_XEMBED_H__ */
/* XEMBED messages */
-#define XEMBED_EMBEDDED_NOTIFY 0
-#define XEMBED_WINDOW_ACTIVATE 1
-#define XEMBED_WINDOW_DEACTIVATE 2
-#define XEMBED_REQUEST_FOCUS 3
-#define XEMBED_FOCUS_IN 4
-#define XEMBED_FOCUS_OUT 5
-#define XEMBED_FOCUS_NEXT 6
-#define XEMBED_FOCUS_PREV 7
-#define XEMBED_GRAB_KEY 8
-#define XEMBED_UNGRAB_KEY 9
-#define XEMBED_MODALITY_ON 10
-#define XEMBED_MODALITY_OFF 11
+typedef enum {
+ XEMBED_EMBEDDED_NOTIFY = 0,
+ XEMBED_WINDOW_ACTIVATE = 1,
+ XEMBED_WINDOW_DEACTIVATE = 2,
+ XEMBED_REQUEST_FOCUS = 3,
+ XEMBED_FOCUS_IN = 4,
+ XEMBED_FOCUS_OUT = 5,
+ XEMBED_FOCUS_NEXT = 6,
+ XEMBED_FOCUS_PREV = 7,
+ XEMBED_GRAB_KEY = 8,
+ XEMBED_UNGRAB_KEY = 9,
+ XEMBED_MODALITY_ON = 10,
+ XEMBED_MODALITY_OFF = 11,
/* Non standard messages*/
-#define XEMBED_GTK_GRAB_KEY 108
-#define XEMBED_GTK_UNGRAB_KEY 109
+ XEMBED_GTK_GRAB_KEY = 108,
+ XEMBED_GTK_UNGRAB_KEY = 109
+} XEmbedMessageType;
/* Details for XEMBED_FOCUS_IN: */
-#define XEMBED_FOCUS_CURRENT 0
-#define XEMBED_FOCUS_FIRST 1
-#define XEMBED_FOCUS_LAST 2
+#define XEMBED_FOCUS_CURRENT 0
+#define XEMBED_FOCUS_FIRST 1
+#define XEMBED_FOCUS_LAST 2
+/* Flags for XEMBED_FOCUS_IN, XEMBED_FOCUS_NEXT, XEMBED_FOCUS_PREV */
+#define XEMBED_FOCUS_WRAPAROUND (1 << 0)
/* Flags for _XEMBED_INFO */
#define XEMBED_MAPPED (1 << 0)
+
projects / gtk4.git / commitdiff